home *** CD-ROM | disk | FTP | other *** search
/ Ultra Pack / UltraComputing Partner Applications.iso / SunLabs / tclTK / src / tcl7.4 / tclUnixStr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-29  |  15.5 KB  |  722 lines
  1. /* 
  2.  * tclUnixStr.c --
  3.  *
  4.  *    This file contains procedures that generate strings
  5.  *    corresponding to various UNIX-related codes, such
  6.  *    as errno and signals.
  7.  *
  8.  * Copyright (c) 1991-1994 The Regents of the University of California.
  9.  * Copyright (c) 1994 Sun Microsystems, Inc.
  10.  *
  11.  * See the file "license.terms" for information on usage and redistribution
  12.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  13.  */
  14.  
  15. #ifndef lint
  16. static char sccsid[] = "@(#) tclUnixStr.c 1.24 95/06/29 08:21:25";
  17. #endif /* not lint */
  18.  
  19. #include "tclInt.h"
  20. #include "tclPort.h"
  21.  
  22. /*
  23.  *----------------------------------------------------------------------
  24.  *
  25.  * Tcl_ErrnoId --
  26.  *
  27.  *    Return a textual identifier for the current errno value.
  28.  *
  29.  * Results:
  30.  *    This procedure returns a machine-readable textual identifier
  31.  *    that corresponds to the current errno value (e.g. "EPERM").
  32.  *    The identifier is the same as the #define name in errno.h.
  33.  *
  34.  * Side effects:
  35.  *    None.
  36.  *
  37.  *----------------------------------------------------------------------
  38.  */
  39.  
  40. char *
  41. Tcl_ErrnoId()
  42. {
  43.     switch (errno) {
  44. #ifdef E2BIG
  45.     case E2BIG: return "E2BIG";
  46. #endif
  47. #ifdef EACCES
  48.     case EACCES: return "EACCES";
  49. #endif
  50. #ifdef EADDRINUSE
  51.     case EADDRINUSE: return "EADDRINUSE";
  52. #endif
  53. #ifdef EADDRNOTAVAIL
  54.     case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
  55. #endif
  56. #ifdef EADV
  57.     case EADV: return "EADV";
  58. #endif
  59. #ifdef EAFNOSUPPORT
  60.     case EAFNOSUPPORT: return "EAFNOSUPPORT";
  61. #endif
  62. #ifdef EAGAIN
  63.     case EAGAIN: return "EAGAIN";
  64. #endif
  65. #ifdef EALIGN
  66.     case EALIGN: return "EALIGN";
  67. #endif
  68. #if defined(EALREADY) && (!defined(EBUSY) || (EALREADY != EBUSY ))
  69.     case EALREADY: return "EALREADY";
  70. #endif
  71. #ifdef EBADE
  72.     case EBADE: return "EBADE";
  73. #endif
  74. #ifdef EBADF
  75.     case EBADF: return "EBADF";
  76. #endif
  77. #ifdef EBADFD
  78.     case EBADFD: return "EBADFD";
  79. #endif
  80. #ifdef EBADMSG
  81.     case EBADMSG: return "EBADMSG";
  82. #endif
  83. #ifdef EBADR
  84.     case EBADR: return "EBADR";
  85. #endif
  86. #ifdef EBADRPC
  87.     case EBADRPC: return "EBADRPC";
  88. #endif
  89. #ifdef EBADRQC
  90.     case EBADRQC: return "EBADRQC";
  91. #endif
  92. #ifdef EBADSLT
  93.     case EBADSLT: return "EBADSLT";
  94. #endif
  95. #ifdef EBFONT
  96.     case EBFONT: return "EBFONT";
  97. #endif
  98. #ifdef EBUSY
  99.     case EBUSY: return "EBUSY";
  100. #endif
  101. #ifdef ECHILD
  102.     case ECHILD: return "ECHILD";
  103. #endif
  104. #ifdef ECHRNG
  105.     case ECHRNG: return "ECHRNG";
  106. #endif
  107. #ifdef ECOMM
  108.     case ECOMM: return "ECOMM";
  109. #endif
  110. #ifdef ECONNABORTED
  111.     case ECONNABORTED: return "ECONNABORTED";
  112. #endif
  113. #ifdef ECONNREFUSED
  114.     case ECONNREFUSED: return "ECONNREFUSED";
  115. #endif
  116. #ifdef ECONNRESET
  117.     case ECONNRESET: return "ECONNRESET";
  118. #endif
  119. #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
  120.     case EDEADLK: return "EDEADLK";
  121. #endif
  122. #ifdef EDEADLOCK
  123.     case EDEADLOCK: return "EDEADLOCK";
  124. #endif
  125. #ifdef EDESTADDRREQ
  126.     case EDESTADDRREQ: return "EDESTADDRREQ";
  127. #endif
  128. #ifdef EDIRTY
  129.     case EDIRTY: return "EDIRTY";
  130. #endif
  131. #ifdef EDOM
  132.     case EDOM: return "EDOM";
  133. #endif
  134. #ifdef EDOTDOT
  135.     case EDOTDOT: return "EDOTDOT";
  136. #endif
  137. #ifdef EDQUOT
  138.     case EDQUOT: return "EDQUOT";
  139. #endif
  140. #ifdef EDUPPKG
  141.     case EDUPPKG: return "EDUPPKG";
  142. #endif
  143. #ifdef EEXIST
  144.     case EEXIST: return "EEXIST";
  145. #endif
  146. #ifdef EFAULT
  147.     case EFAULT: return "EFAULT";
  148. #endif
  149. #ifdef EFBIG
  150.     case EFBIG: return "EFBIG";
  151. #endif
  152. #ifdef EHOSTDOWN
  153.     case EHOSTDOWN: return "EHOSTDOWN";
  154. #endif
  155. #ifdef EHOSTUNREACH
  156.     case EHOSTUNREACH: return "EHOSTUNREACH";
  157. #endif
  158. #if defined(EIDRM) && (!defined(EINPROGRESS) || (EIDRM != EINPROGRESS))
  159.     case EIDRM: return "EIDRM";
  160. #endif
  161. #ifdef EINIT
  162.     case EINIT: return "EINIT";
  163. #endif
  164. #ifdef EINPROGRESS
  165.     case EINPROGRESS: return "EINPROGRESS";
  166. #endif
  167. #ifdef EINTR
  168.     case EINTR: return "EINTR";
  169. #endif
  170. #ifdef EINVAL
  171.     case EINVAL: return "EINVAL";
  172. #endif
  173. #ifdef EIO
  174.     case EIO: return "EIO";
  175. #endif
  176. #ifdef EISCONN
  177.     case EISCONN: return "EISCONN";
  178. #endif
  179. #ifdef EISDIR
  180.     case EISDIR: return "EISDIR";
  181. #endif
  182. #ifdef EISNAME
  183.     case EISNAM: return "EISNAM";
  184. #endif
  185. #ifdef ELBIN
  186.     case ELBIN: return "ELBIN";
  187. #endif
  188. #ifdef EL2HLT
  189.     case EL2HLT: return "EL2HLT";
  190. #endif
  191. #ifdef EL2NSYNC
  192.     case EL2NSYNC: return "EL2NSYNC";
  193. #endif
  194. #ifdef EL3HLT
  195.     case EL3HLT: return "EL3HLT";
  196. #endif
  197. #ifdef EL3RST
  198.     case EL3RST: return "EL3RST";
  199. #endif
  200. #ifdef ELIBACC
  201.     case ELIBACC: return "ELIBACC";
  202. #endif
  203. #ifdef ELIBBAD
  204.     case ELIBBAD: return "ELIBBAD";
  205. #endif
  206. #ifdef ELIBEXEC
  207.     case ELIBEXEC: return "ELIBEXEC";
  208. #endif
  209. #ifdef ELIBMAX
  210.     case ELIBMAX: return "ELIBMAX";
  211. #endif
  212. #ifdef ELIBSCN
  213.     case ELIBSCN: return "ELIBSCN";
  214. #endif
  215. #ifdef ELNRNG
  216.     case ELNRNG: return "ELNRNG";
  217. #endif
  218. #ifdef ELOOP
  219.     case ELOOP: return "ELOOP";
  220. #endif
  221. #ifdef EMFILE
  222.     case EMFILE: return "EMFILE";
  223. #endif
  224. #ifdef EMLINK
  225.     case EMLINK: return "EMLINK";
  226. #endif
  227. #ifdef EMSGSIZE
  228.     case EMSGSIZE: return "EMSGSIZE";
  229. #endif
  230. #ifdef EMULTIHOP
  231.     case EMULTIHOP: return "EMULTIHOP";
  232. #endif
  233. #ifdef ENAMETOOLONG
  234.     case ENAMETOOLONG: return "ENAMETOOLONG";
  235. #endif
  236. #ifdef ENAVAIL
  237.     case ENAVAIL: return "ENAVAIL";
  238. #endif
  239. #ifdef ENET
  240.     case ENET: return "ENET";
  241. #endif
  242. #ifdef ENETDOWN
  243.     case ENETDOWN: return "ENETDOWN";
  244. #endif
  245. #ifdef ENETRESET
  246.     case ENETRESET: return "ENETRESET";
  247. #endif
  248. #ifdef ENETUNREACH
  249.     case ENETUNREACH: return "ENETUNREACH";
  250. #endif
  251. #ifdef ENFILE
  252.     case ENFILE: return "ENFILE";
  253. #endif
  254. #ifdef ENOANO
  255.     case ENOANO: return "ENOANO";
  256. #endif
  257. #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
  258.     case ENOBUFS: return "ENOBUFS";
  259. #endif
  260. #ifdef ENOCSI
  261.     case ENOCSI: return "ENOCSI";
  262. #endif
  263. #if defined(ENODATA) && (!defined(ECONNREFUSED) || (ENODATA != ECONNREFUSED))
  264.     case ENODATA: return "ENODATA";
  265. #endif
  266. #ifdef ENODEV
  267.     case ENODEV: return "ENODEV";
  268. #endif
  269. #ifdef ENOENT
  270.     case ENOENT: return "ENOENT";
  271. #endif
  272. #ifdef ENOEXEC
  273.     case ENOEXEC: return "ENOEXEC";
  274. #endif
  275. #ifdef ENOLCK
  276.     case ENOLCK: return "ENOLCK";
  277. #endif
  278. #ifdef ENOLINK
  279.     case ENOLINK: return "ENOLINK";
  280. #endif
  281. #ifdef ENOMEM
  282.     case ENOMEM: return "ENOMEM";
  283. #endif
  284. #ifdef ENOMSG
  285.     case ENOMSG: return "ENOMSG";
  286. #endif
  287. #ifdef ENONET
  288.     case ENONET: return "ENONET";
  289. #endif
  290. #ifdef ENOPKG
  291.     case ENOPKG: return "ENOPKG";
  292. #endif
  293. #ifdef ENOPROTOOPT
  294.     case ENOPROTOOPT: return "ENOPROTOOPT";
  295. #endif
  296. #ifdef ENOSPC
  297.     case ENOSPC: return "ENOSPC";
  298. #endif
  299. #if defined(ENOSR) && (!defined(ENAMETOOLONG) || (ENAMETOOLONG != ENOSR))
  300.     case ENOSR: return "ENOSR";
  301. #endif
  302. #if defined(ENOSTR) && (!defined(ENOTTY) || (ENOTTY != ENOSTR))
  303.     case ENOSTR: return "ENOSTR";
  304. #endif
  305. #ifdef ENOSYM
  306.     case ENOSYM: return "ENOSYM";
  307. #endif
  308. #ifdef ENOSYS
  309.     case ENOSYS: return "ENOSYS";
  310. #endif
  311. #ifdef ENOTBLK
  312.     case ENOTBLK: return "ENOTBLK";
  313. #endif
  314. #ifdef ENOTCONN
  315.     case ENOTCONN: return "ENOTCONN";
  316. #endif
  317. #ifdef ENOTDIR
  318.     case ENOTDIR: return "ENOTDIR";
  319. #endif
  320. #if defined(ENOTEMPTY) && (!defined(EEXIST) || (ENOTEMPTY != EEXIST))
  321.     case ENOTEMPTY: return "ENOTEMPTY";
  322. #endif
  323. #ifdef ENOTNAM
  324.     case ENOTNAM: return "ENOTNAM";
  325. #endif
  326. #ifdef ENOTSOCK
  327.     case ENOTSOCK: return "ENOTSOCK";
  328. #endif
  329. #ifdef ENOTTY
  330.     case ENOTTY: return "ENOTTY";
  331. #endif
  332. #ifdef ENOTUNIQ
  333.     case ENOTUNIQ: return "ENOTUNIQ";
  334. #endif
  335. #ifdef ENXIO
  336.     case ENXIO: return "ENXIO";
  337. #endif
  338. #ifdef EOPNOTSUPP
  339.     case EOPNOTSUPP: return "EOPNOTSUPP";
  340. #endif
  341. #ifdef EPERM
  342.     case EPERM: return "EPERM";
  343. #endif
  344. #if defined(EPFNOSUPPORT) && (!defined(ENOLCK) || (ENOLCK != EPFNOSUPPORT))
  345.     case EPFNOSUPPORT: return "EPFNOSUPPORT";
  346. #endif
  347. #ifdef EPIPE
  348.     case EPIPE: return "EPIPE";
  349. #endif
  350. #ifdef EPROCLIM
  351.     case EPROCLIM: return "EPROCLIM";
  352. #endif
  353. #ifdef EPROCUNAVAIL
  354.     case EPROCUNAVAIL: return "EPROCUNAVAIL";
  355. #endif
  356. #ifdef EPROGMISMATCH
  357.     case EPROGMISMATCH: return "EPROGMISMATCH";
  358. #endif
  359. #ifdef EPROGUNAVAIL
  360.     case EPROGUNAVAIL: return "EPROGUNAVAIL";
  361. #endif
  362. #ifdef EPROTO
  363.     case EPROTO: return "EPROTO";
  364. #endif
  365. #ifdef EPROTONOSUPPORT
  366.     case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
  367. #endif
  368. #ifdef EPROTOTYPE
  369.     case EPROTOTYPE: return "EPROTOTYPE";
  370. #endif
  371. #ifdef ERANGE
  372.     case ERANGE: return "ERANGE";
  373. #endif
  374. #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
  375.     case EREFUSED: return "EREFUSED";
  376. #endif
  377. #ifdef EREMCHG
  378.     case EREMCHG: return "EREMCHG";
  379. #endif
  380. #ifdef EREMDEV
  381.     case EREMDEV: return "EREMDEV";
  382. #endif
  383. #ifdef EREMOTE
  384.     case EREMOTE: return "EREMOTE";
  385. #endif
  386. #ifdef EREMOTEIO
  387.     case EREMOTEIO: return "EREMOTEIO";
  388. #endif
  389. #ifdef EREMOTERELEASE
  390.     case EREMOTERELEASE: return "EREMOTERELEASE";
  391. #endif
  392. #ifdef EROFS
  393.     case EROFS: return "EROFS";
  394. #endif
  395. #ifdef ERPCMISMATCH
  396.     case ERPCMISMATCH: return "ERPCMISMATCH";
  397. #endif
  398. #ifdef ERREMOTE
  399.     case ERREMOTE: return "ERREMOTE";
  400. #endif
  401. #ifdef ESHUTDOWN
  402.     case ESHUTDOWN: return "ESHUTDOWN";
  403. #endif
  404. #ifdef ESOCKTNOSUPPORT
  405.     case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT";
  406. #endif
  407. #ifdef ESPIPE
  408.     case ESPIPE: return "ESPIPE";
  409. #endif
  410. #ifdef ESRCH
  411.     case ESRCH: return "ESRCH";
  412. #endif
  413. #ifdef ESRMNT
  414.     case ESRMNT: return "ESRMNT";
  415. #endif
  416. #ifdef ESTALE
  417.     case ESTALE: return "ESTALE";
  418. #endif
  419. #ifdef ESUCCESS
  420.     case ESUCCESS: return "ESUCCESS";
  421. #endif
  422. #if defined(ETIME) && (!defined(ELOOP) || (ETIME != ELOOP))
  423.     case ETIME: return "ETIME";
  424. #endif
  425. #if defined(ETIMEDOUT) && (!defined(ENOSTR) || (ETIMEDOUT != ENOSTR))
  426.     case ETIMEDOUT: return "ETIMEDOUT";
  427. #endif
  428. #ifdef ETOOMANYREFS
  429.     case ETOOMANYREFS: return "ETOOMANYREFS";
  430. #endif
  431. #ifdef ETXTBSY
  432.     case ETXTBSY: return "ETXTBSY";
  433. #endif
  434. #ifdef EUCLEAN
  435.     case EUCLEAN: return "EUCLEAN";
  436. #endif
  437. #ifdef EUNATCH
  438.     case EUNATCH: return "EUNATCH";
  439. #endif
  440. #ifdef EUSERS
  441.     case EUSERS: return "EUSERS";
  442. #endif
  443. #ifdef EVERSION
  444.     case EVERSION: return "EVERSION";
  445. #endif
  446. #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
  447.     case EWOULDBLOCK: return "EWOULDBLOCK";
  448. #endif
  449. #ifdef EXDEV
  450.     case EXDEV: return "EXDEV";
  451. #endif
  452. #ifdef EXFULL
  453.     case EXFULL: return "EXFULL";
  454. #endif
  455.     }
  456.     return "unknown error";
  457. }
  458.  
  459. /*
  460.  *----------------------------------------------------------------------
  461.  *
  462.  * Tcl_SignalId --
  463.  *
  464.  *    Return a textual identifier for a signal number.
  465.  *
  466.  * Results:
  467.  *    This procedure returns a machine-readable textual identifier
  468.  *    that corresponds to sig.  The identifier is the same as the
  469.  *    #define name in signal.h.
  470.  *
  471.  * Side effects:
  472.  *    None.
  473.  *
  474.  *----------------------------------------------------------------------
  475.  */
  476.  
  477. char *
  478. Tcl_SignalId(sig)
  479.     int sig;            /* Number of signal. */
  480. {
  481.     switch (sig) {
  482. #ifdef SIGABRT
  483.     case SIGABRT: return "SIGABRT";
  484. #endif
  485. #ifdef SIGALRM
  486.     case SIGALRM: return "SIGALRM";
  487. #endif
  488. #ifdef SIGBUS
  489.     case SIGBUS: return "SIGBUS";
  490. #endif
  491. #ifdef SIGCHLD
  492.     case SIGCHLD: return "SIGCHLD";
  493. #endif
  494. #if defined(SIGCLD) && (!defined(SIGCHLD) || (SIGCLD != SIGCHLD))
  495.     case SIGCLD: return "SIGCLD";
  496. #endif
  497. #ifdef SIGCONT
  498.     case SIGCONT: return "SIGCONT";
  499. #endif
  500. #if defined(SIGEMT) && (!defined(SIGXCPU) || (SIGEMT != SIGXCPU))
  501.     case SIGEMT: return "SIGEMT";
  502. #endif
  503. #ifdef SIGFPE
  504.     case SIGFPE: return "SIGFPE";
  505. #endif
  506. #ifdef SIGHUP
  507.     case SIGHUP: return "SIGHUP";
  508. #endif
  509. #ifdef SIGILL
  510.     case SIGILL: return "SIGILL";
  511. #endif
  512. #ifdef SIGINT
  513.     case SIGINT: return "SIGINT";
  514. #endif
  515. #ifdef SIGIO
  516.     case SIGIO: return "SIGIO";
  517. #endif
  518. #if defined(SIGIOT) && (!defined(SIGABRT) || (SIGIOT != SIGABRT))
  519.     case SIGIOT: return "SIGIOT";
  520. #endif
  521. #ifdef SIGKILL
  522.     case SIGKILL: return "SIGKILL";
  523. #endif
  524. #if defined(SIGLOST) && (!defined(SIGIOT) || (SIGLOST != SIGIOT)) && (!defined(SIGURG) || (SIGLOST != SIGURG)) && (!defined(SIGPROF) || (SIGLOST != SIGPROF))
  525.     case SIGLOST: return "SIGLOST";
  526. #endif
  527. #ifdef SIGPIPE
  528.     case SIGPIPE: return "SIGPIPE";
  529. #endif
  530. #if defined(SIGPOLL) && (!defined(SIGIO) || (SIGPOLL != SIGIO))
  531.     case SIGPOLL: return "SIGPOLL";
  532. #endif
  533. #ifdef SIGPROF
  534.     case SIGPROF: return "SIGPROF";
  535. #endif
  536. #if defined(SIGPWR) && (!defined(SIGXFSZ) || (SIGPWR != SIGXFSZ))
  537.     case SIGPWR: return "SIGPWR";
  538. #endif
  539. #ifdef SIGQUIT
  540.     case SIGQUIT: return "SIGQUIT";
  541. #endif
  542. #ifdef SIGSEGV
  543.     case SIGSEGV: return "SIGSEGV";
  544. #endif
  545. #ifdef SIGSTOP
  546.     case SIGSTOP: return "SIGSTOP";
  547. #endif
  548. #ifdef SIGSYS
  549.     case SIGSYS: return "SIGSYS";
  550. #endif
  551. #ifdef SIGTERM
  552.     case SIGTERM: return "SIGTERM";
  553. #endif
  554. #ifdef SIGTRAP
  555.     case SIGTRAP: return "SIGTRAP";
  556. #endif
  557. #ifdef SIGTSTP
  558.     case SIGTSTP: return "SIGTSTP";
  559. #endif
  560. #ifdef SIGTTIN
  561.     case SIGTTIN: return "SIGTTIN";
  562. #endif
  563. #ifdef SIGTTOU
  564.     case SIGTTOU: return "SIGTTOU";
  565. #endif
  566. #if defined(SIGURG) && (!defined(SIGIO) || (SIGURG != SIGIO))
  567.     case SIGURG: return "SIGURG";
  568. #endif
  569. #if defined(SIGUSR1) && (!defined(SIGIO) || (SIGUSR1 != SIGIO))
  570.     case SIGUSR1: return "SIGUSR1";
  571. #endif
  572. #if defined(SIGUSR2) && (!defined(SIGURG) || (SIGUSR2 != SIGURG))
  573.     case SIGUSR2: return "SIGUSR2";
  574. #endif
  575. #ifdef SIGVTALRM
  576.     case SIGVTALRM: return "SIGVTALRM";
  577. #endif
  578. #ifdef SIGWINCH
  579.     case SIGWINCH: return "SIGWINCH";
  580. #endif
  581. #ifdef SIGXCPU
  582.     case SIGXCPU: return "SIGXCPU";
  583. #endif
  584. #ifdef SIGXFSZ
  585.     case SIGXFSZ: return "SIGXFSZ";
  586. #endif
  587.     }
  588.     return "unknown signal";
  589. }
  590.  
  591. /*
  592.  *----------------------------------------------------------------------
  593.  *
  594.  * Tcl_SignalMsg --
  595.  *
  596.  *    Return a human-readable message describing a signal.
  597.  *
  598.  * Results:
  599.  *    This procedure returns a string describing sig that should
  600.  *    make sense to a human.  It may not be easy for a machine
  601.  *    to parse.
  602.  *
  603.  * Side effects:
  604.  *    None.
  605.  *
  606.  *----------------------------------------------------------------------
  607.  */
  608.  
  609. char *
  610. Tcl_SignalMsg(sig)
  611.     int sig;            /* Number of signal. */
  612. {
  613.     switch (sig) {
  614. #ifdef SIGABRT
  615.     case SIGABRT: return "SIGABRT";
  616. #endif
  617. #ifdef SIGALRM
  618.     case SIGALRM: return "alarm clock";
  619. #endif
  620. #ifdef SIGBUS
  621.     case SIGBUS: return "bus error";
  622. #endif
  623. #ifdef SIGCHLD
  624.     case SIGCHLD: return "child status changed";
  625. #endif
  626. #if defined(SIGCLD) && (!defined(SIGCHLD) || (SIGCLD != SIGCHLD))
  627.     case SIGCLD: return "child status changed";
  628. #endif
  629. #ifdef SIGCONT
  630.     case SIGCONT: return "continue after stop";
  631. #endif
  632. #if defined(SIGEMT) && (!defined(SIGXCPU) || (SIGEMT != SIGXCPU))
  633.     case SIGEMT: return "EMT instruction";
  634. #endif
  635. #ifdef SIGFPE
  636.     case SIGFPE: return "floating-point exception";
  637. #endif
  638. #ifdef SIGHUP
  639.     case SIGHUP: return "hangup";
  640. #endif
  641. #ifdef SIGILL
  642.     case SIGILL: return "illegal instruction";
  643. #endif
  644. #ifdef SIGINT
  645.     case SIGINT: return "interrupt";
  646. #endif
  647. #ifdef SIGIO
  648.     case SIGIO: return "input/output possible on file";
  649. #endif
  650. #if defined(SIGIOT) && (!defined(SIGABRT) || (SIGABRT != SIGIOT))
  651.     case SIGIOT: return "IOT instruction";
  652. #endif
  653. #ifdef SIGKILL
  654.     case SIGKILL: return "kill signal";
  655. #endif
  656. #if defined(SIGLOST) && (!defined(SIGIOT) || (SIGLOST != SIGIOT)) && (!defined(SIGURG) || (SIGLOST != SIGURG))
  657.     case SIGLOST: return "resource lost";
  658. #endif
  659. #ifdef SIGPIPE
  660.     case SIGPIPE: return "write on pipe with no readers";
  661. #endif
  662. #if defined(SIGPOLL) && (!defined(SIGIO) || (SIGPOLL != SIGIO))
  663.     case SIGPOLL: return "input/output possible on file";
  664. #endif
  665. #ifdef SIGPROF
  666.     case SIGPROF: return "profiling alarm";
  667. #endif
  668. #if defined(SIGPWR) && (!defined(SIGXFSZ) || (SIGPWR != SIGXFSZ))
  669.     case SIGPWR: return "power-fail restart";
  670. #endif
  671. #ifdef SIGQUIT
  672.     case SIGQUIT: return "quit signal";
  673. #endif
  674. #ifdef SIGSEGV
  675.     case SIGSEGV: return "segmentation violation";
  676. #endif
  677. #ifdef SIGSTOP
  678.     case SIGSTOP: return "stop";
  679. #endif
  680. #ifdef SIGSYS
  681.     case SIGSYS: return "bad argument to system call";
  682. #endif
  683. #ifdef SIGTERM
  684.     case SIGTERM: return "software termination signal";
  685. #endif
  686. #ifdef SIGTRAP
  687.     case SIGTRAP: return "trace trap";
  688. #endif
  689. #ifdef SIGTSTP
  690.     case SIGTSTP: return "stop signal from tty";
  691. #endif
  692. #ifdef SIGTTIN
  693.     case SIGTTIN: return "background tty read";
  694. #endif
  695. #ifdef SIGTTOU
  696.     case SIGTTOU: return "background tty write";
  697. #endif
  698. #if defined(SIGURG) && (!defined(SIGIO) || (SIGURG != SIGIO))
  699.     case SIGURG: return "urgent I/O condition";
  700. #endif
  701. #if defined(SIGUSR1) && (!defined(SIGIO) || (SIGUSR1 != SIGIO))
  702.     case SIGUSR1: return "user-defined signal 1";
  703. #endif
  704. #if defined(SIGUSR2) && (!defined(SIGURG) || (SIGUSR2 != SIGURG))
  705.     case SIGUSR2: return "user-defined signal 2";
  706. #endif
  707. #ifdef SIGVTALRM
  708.     case SIGVTALRM: return "virtual time alarm";
  709. #endif
  710. #ifdef SIGWINCH
  711.     case SIGWINCH: return "window changed";
  712. #endif
  713. #ifdef SIGXCPU
  714.     case SIGXCPU: return "exceeded CPU time limit";
  715. #endif
  716. #ifdef SIGXFSZ
  717.     case SIGXFSZ: return "exceeded file size limit";
  718. #endif
  719.     }
  720.     return "unknown signal";
  721. }
  722.